home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet internetowy / Przegladarki internetowe / Mozilla Seamonkey 1.0.5 pl / seamonkey-1.0.5.pl-PL.win32.installer.exe / VENKMAN.XPI / bin / components / venkman-service.js
Encoding:
Text File  |  2006-09-10  |  16.1 KB  |  565 lines
  1. /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  2.  *
  3.  * ***** BEGIN LICENSE BLOCK *****
  4.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  5.  *
  6.  * The contents of this file are subject to the Mozilla Public License Version
  7.  * 1.1 (the "License"); you may not use this file except in compliance with
  8.  * the License. You may obtain a copy of the License at
  9.  * http://www.mozilla.org/MPL/
  10.  *
  11.  * Software distributed under the License is distributed on an "AS IS" basis,
  12.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13.  * for the specific language governing rights and limitations under the
  14.  * License.
  15.  *
  16.  * The Original Code is The JavaScript Debugger.
  17.  *
  18.  * The Initial Developer of the Original Code is
  19.  * Netscape Communications Corporation.
  20.  * Portions created by the Initial Developer are Copyright (C) 1998
  21.  * the Initial Developer. All Rights Reserved.
  22.  *
  23.  * Contributor(s):
  24.  *   Robert Ginda, <rginda@netscape.com>, original author
  25.  *
  26.  * Alternatively, the contents of this file may be used under the terms of
  27.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  28.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29.  * in which case the provisions of the GPL or the LGPL are applicable instead
  30.  * of those above. If you wish to allow use of your version of this file only
  31.  * under the terms of either the GPL or the LGPL, and not to allow others to
  32.  * use your version of this file under the terms of the MPL, indicate your
  33.  * decision by deleting the provisions above and replace them with the notice
  34.  * and other provisions required by the GPL or the LGPL. If you do not delete
  35.  * the provisions above, a recipient may use your version of this file under
  36.  * the terms of any one of the MPL, the GPL or the LGPL.
  37.  *
  38.  * ***** END LICENSE BLOCK ***** */
  39.  
  40. /* components defined in this file */
  41. const CLINE_SERVICE_CTRID =
  42.     "@mozilla.org/commandlinehandler/general-startup;1?type=venkman";
  43. const CLINE_SERVICE_CID =
  44.     Components.ID("{18269616-1dd2-11b2-afa8-b612439bda27}");
  45. const JSDPROT_HANDLER_CTRID =
  46.     "@mozilla.org/network/protocol;1?name=x-jsd";
  47. const JSDPROT_HANDLER_CID =
  48.     Components.ID("{12ec790d-304e-4525-89a9-3e723d489d14}");
  49. const JSDCNT_HANDLER_CTRID =
  50.     "@mozilla.org/uriloader/content-handler;1?type=x-application-jsd";
  51. const JSDCNT_HANDLER_CID =
  52.     Components.ID("{306670f0-47bb-466b-b53b-613235623bbd}");
  53.  
  54. /* components used by this file */
  55. const CATMAN_CTRID = "@mozilla.org/categorymanager;1";
  56. const STRING_STREAM_CTRID = "@mozilla.org/io/string-input-stream;1";
  57. const MEDIATOR_CTRID =
  58.     "@mozilla.org/appshell/window-mediator;1";
  59. const ASS_CONTRACTID =
  60.     "@mozilla.org/appshell/appShellService;1";
  61. const SIMPLEURI_CTRID = "@mozilla.org/network/simple-uri;1";
  62.  
  63. const nsIWindowMediator    = Components.interfaces.nsIWindowMediator;
  64. const nsIAppShellService   = Components.interfaces.nsIAppShellService;
  65. const nsICmdLineHandler    = Components.interfaces.nsICmdLineHandler;
  66. const nsICategoryManager   = Components.interfaces.nsICategoryManager;
  67. const nsIContentHandler    = Components.interfaces.nsIContentHandler;
  68. const nsIProtocolHandler   = Components.interfaces.nsIProtocolHandler;
  69. const nsIURI               = Components.interfaces.nsIURI;
  70. const nsIURL               = Components.interfaces.nsIURL;
  71. const nsIStringInputStream = Components.interfaces.nsIStringInputStream;
  72. const nsIChannel           = Components.interfaces.nsIChannel;
  73. const nsIRequest           = Components.interfaces.nsIRequest;
  74. const nsIProgressEventSink = Components.interfaces.nsIProgressEventSink;
  75. const nsISupports          = Components.interfaces.nsISupports;
  76.  
  77. function findDebuggerWindow ()
  78. {
  79.     var windowManager =
  80.         Components.classes[MEDIATOR_CTRID].getService(nsIWindowMediator);
  81.  
  82.     var window = windowManager.getMostRecentWindow("mozapp:venkman");
  83.  
  84.     return window;
  85. }
  86.  
  87. function safeHTML(str)
  88. {
  89.     function replaceChars(ch)
  90.     {
  91.         switch (ch)
  92.         {
  93.             case "<":
  94.                 return "<";
  95.             
  96.             case ">":
  97.                 return ">";
  98.                     
  99.             case "&":
  100.                 return "&";
  101.         }
  102.  
  103.         return "?";
  104.     };
  105.         
  106.     return String(str).replace(/[<>&]/g, replaceChars);
  107. }
  108.  
  109. /* Command Line handler service */
  110. function CLineService()
  111. {}
  112.  
  113. CLineService.prototype.commandLineArgument = "-venkman";
  114. CLineService.prototype.prefNameForStartup = "general.startup.venkman";
  115. CLineService.prototype.chromeUrlForTask = "chrome://venkman/content";
  116. CLineService.prototype.helpText = "Start with JavaScript Debugger.";
  117. CLineService.prototype.handlesArgs = false;
  118. CLineService.prototype.defaultArgs = "";
  119. CLineService.prototype.openWindowWithArgs = false;
  120.  
  121. /* factory for command line handler service (CLineService) */
  122. var CLineFactory = new Object();
  123.  
  124. CLineFactory.createInstance =
  125. function clf_create (outer, iid) {
  126.     if (outer != null)
  127.         throw Components.results.NS_ERROR_NO_AGGREGATION;
  128.  
  129.     if (!iid.equals(nsICmdLineHandler) && !iid.equals(nsISupports))
  130.         throw Components.results.NS_ERROR_INVALID_ARG;
  131.  
  132.     return new CLineService();
  133. }
  134.  
  135. /* x-jsd: protocol handler */
  136.  
  137. const JSD_DEFAULT_PORT = 2206; /* Dana's apartment number. */
  138.  
  139. /* protocol handler factory object */
  140. var JSDProtocolHandlerFactory = new Object();
  141.  
  142. JSDProtocolHandlerFactory.createInstance =
  143. function jsdhf_create (outer, iid) {
  144.     if (outer != null)
  145.         throw Components.results.NS_ERROR_NO_AGGREGATION;
  146.  
  147.     if (!iid.equals(nsIProtocolHandler) && !iid.equals(nsISupports))
  148.         throw Components.results.NS_ERROR_INVALID_ARG;
  149.  
  150.     return new JSDProtocolHandler();
  151. }
  152.  
  153. function JSDURI (spec, charset)
  154. {
  155.     this.spec = this.prePath = spec;
  156.     this.charset = this.originCharset = charset;
  157. }
  158.  
  159. JSDURI.prototype.QueryInterface =
  160. function jsdch_qi (iid)
  161. {
  162.     if (!iid.equals(nsIURI) && !iid.equals(nsIURL) &&
  163.         !iid.equals(nsISupports))
  164.         throw Components.results.NS_ERROR_NO_INTERFACE;
  165.  
  166.     return this;
  167. }
  168.  
  169. JSDURI.prototype.scheme = "x-jsd";
  170.  
  171. JSDURI.prototype.fileBaseName =
  172. JSDURI.prototype.fileExtension =
  173. JSDURI.prototype.filePath  =
  174. JSDURI.prototype.param     =
  175. JSDURI.prototype.query     =
  176. JSDURI.prototype.ref       =
  177. JSDURI.prototype.directory =
  178. JSDURI.prototype.fileName  =
  179. JSDURI.prototype.username  =
  180. JSDURI.prototype.password  =
  181. JSDURI.prototype.hostPort  =
  182. JSDURI.prototype.path      =
  183. JSDURI.prototype.asciiHost =
  184. JSDURI.prototype.userPass  = "";
  185.  
  186. JSDURI.prototype.port = JSD_DEFAULT_PORT;
  187.  
  188. JSDURI.prototype.schemeIs =
  189. function jsduri_schemeis (scheme)
  190. {
  191.     return scheme.toLowerCase() == "x-jsd";
  192. }
  193.  
  194. JSDURI.prototype.getCommonBaseSpec =
  195. function jsduri_commonbase (uri)
  196. {
  197.     return "x-jsd:";
  198. }
  199.  
  200. JSDURI.prototype.getRelativeSpec =
  201. function jsduri_commonbase (uri)
  202. {
  203.     return uri;
  204. }
  205.  
  206. JSDURI.prototype.equals =
  207. function jsduri_equals (uri)
  208. {
  209.     return uri.spec == this.spec;
  210. }
  211.  
  212. JSDURI.prototype.clone =
  213. function jsduri_clone ()
  214. {
  215.     return new JSDURI (this.spec);
  216. }
  217.  
  218. JSDURI.prototype.resolve =
  219. function jsduri_resolve(path)
  220. {
  221.     //dump ("resolve " + path + " from " + this.spec + "\n");
  222.     if (path[0] == "#")
  223.         return this.spec + path;
  224.     
  225.     return path;
  226. }
  227.  
  228. function JSDProtocolHandler()
  229. {
  230.     /* nothing here */
  231. }
  232.  
  233. JSDProtocolHandler.prototype.scheme = "x-jsd";
  234. JSDProtocolHandler.prototype.defaultPort = JSD_DEFAULT_PORT;
  235. JSDProtocolHandler.prototype.protocolFlags = nsIProtocolHandler.URI_NORELATIVE ||
  236.                                              nsIProtocolHandler.URI_NOAUTH;
  237.  
  238. JSDProtocolHandler.prototype.allowPort =
  239. function jsdph_allowport (aPort, aScheme)
  240. {
  241.     return false;
  242. }
  243.  
  244. JSDProtocolHandler.prototype.newURI =
  245. function jsdph_newuri (spec, charset, baseURI)
  246. {
  247.     var clazz = Components.classes[SIMPLEURI_CTRID];
  248.     var uri = clazz.createInstance(nsIURI);
  249.     uri.spec = spec;
  250.     return uri;
  251. }
  252.  
  253. JSDProtocolHandler.prototype.newChannel =
  254. function jsdph_newchannel (uri)
  255. {
  256.     return new JSDChannel (uri);
  257. }
  258.  
  259. function JSDChannel (uri)
  260. {
  261.     this.URI = uri;
  262.     this.originalURI = uri;
  263.     this._isPending = true;
  264.     var clazz = Components.classes[STRING_STREAM_CTRID];
  265.     this.stringStream = clazz.createInstance(nsIStringInputStream);
  266. }
  267.  
  268. JSDChannel.prototype.QueryInterface =
  269. function jsdch_qi (iid)
  270. {
  271.  
  272.     if (!iid.equals(nsIChannel) && !iid.equals(nsIRequest) &&
  273.         !iid.equals(nsISupports))
  274.         throw Components.results.NS_ERROR_NO_INTERFACE;
  275.  
  276.     return this;
  277. }
  278.  
  279. /* nsIChannel */
  280. JSDChannel.prototype.loadAttributes = null;
  281. JSDChannel.prototype.contentType = "text/html";
  282. JSDChannel.prototype.contentLength = -1;
  283. JSDChannel.prototype.owner = null;
  284. JSDChannel.prototype.loadGroup = null;
  285. JSDChannel.prototype.notificationCallbacks = null;
  286. JSDChannel.prototype.securityInfo = null;
  287.  
  288. JSDChannel.prototype.open =
  289. function jsdch_open()
  290. {
  291.     throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
  292. }
  293.  
  294. JSDChannel.prototype.asyncOpen =
  295. function jsdch_aopen (streamListener, context)
  296. {
  297.     this.streamListener = streamListener;
  298.     this.context = context;
  299.     
  300.     if (!window && this.URI.spec == "x-jsd:debugger")
  301.     {
  302.         this.contentType = "x-application-jsd";
  303.         this.contentLength = 0;
  304.         streamListener.onStartRequest(this, context);
  305.         return;
  306.     }
  307.     
  308.     var window = findDebuggerWindow();
  309.     var ary = this.URI.spec.match (/x-jsd:([^:]+)/);
  310.     var exception;
  311.  
  312.     if (this.loadGroup)
  313.         this.loadGroup.addRequest (this, null);
  314.  
  315.     if (window && "console" in window && ary)
  316.     {
  317.         try
  318.         {
  319.             window.asyncOpenJSDURL (this, streamListener, context);
  320.             return;
  321.         }
  322.         catch (ex)
  323.         {
  324.             exception = ex;
  325.         }
  326.     }
  327.  
  328.     var str =
  329.         "<html><head><title>Error</title></head><body>Could not load <<b>" +
  330.         safeHTML(this.URI.spec) + "</b>><br>";
  331.     
  332.     if (!ary)
  333.     {
  334.         str += "<b>Error parsing uri.</b>";
  335.     }
  336.     else if (exception)
  337.     {
  338.         str += "<b>Internal error: " + safeHTML(exception) + "</b><br><pre>" + 
  339.             safeHTML(exception.stack);
  340.     }
  341.     else
  342.     {
  343.         str += "<b>Debugger is not running.</b>";
  344.     }
  345.     
  346.     str += "</body></html>";
  347.     
  348.     this.respond (str);
  349. }
  350.  
  351. JSDChannel.prototype.respond =
  352. function jsdch_respond (str)
  353. {
  354.     this.streamListener.onStartRequest (this, this.context);
  355.  
  356.     var len = str.length;
  357.     this.stringStream.setData (str, len);
  358.     this.streamListener.onDataAvailable (this, this.context,
  359.                                          this.stringStream, 0, len);
  360.     this.streamListener.onStopRequest (this, this.context,
  361.                                        Components.results.NS_OK);
  362.     if (this.loadGroup)
  363.         this.loadGroup.removeRequest (this, null, Components.results.NS_OK);
  364.     this._isPending = false;    
  365. }
  366.  
  367. /* nsIRequest */
  368. JSDChannel.prototype.isPending =
  369. function jsdch_ispending ()
  370. {
  371.     return this._isPending;
  372. }
  373.  
  374. JSDChannel.prototype.status = Components.results.NS_OK;
  375.  
  376. JSDChannel.prototype.cancel =
  377. function jsdch_cancel (status)
  378. {
  379.     if (this._isPending)
  380.     {
  381.         this._isPending = false;
  382.         this.streamListener.onStopRequest (this, this.context, status);
  383.         if (this.loadGroup)
  384.         {
  385.             try
  386.             {
  387.                 this.loadGroup.removeRequest (this, null, status);
  388.             }
  389.             catch (ex)
  390.             {
  391.                 debug ("we're not in the load group?\n");
  392.             }
  393.         }
  394.     }
  395.     
  396.     this.status = status;
  397. }
  398.  
  399. JSDChannel.prototype.suspend =
  400. JSDChannel.prototype.resume =
  401. function jsdch_notimpl ()
  402. {
  403.     throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
  404. }
  405.  
  406. /*****************************************************************************/
  407.  
  408. /* x-application-jsd content handler */
  409. function JSDContentHandler ()
  410. {}
  411.  
  412. JSDContentHandler.prototype.QueryInterface =
  413. function jsdh_qi(iid)
  414. {
  415.     if (!iid.equals(nsIContentHandler) && !iid.equals(nsISupports))
  416.         throw Components.results.NS_ERROR_NO_INTERFACE;
  417.  
  418.     return this;
  419. }
  420.  
  421. JSDContentHandler.prototype.handleContent =
  422. function jsdh_handle(contentType, windowTarget, request)
  423. {
  424.     var e;
  425.     var channel = request.QueryInterface(nsIChannel);
  426.     
  427.     // prevent someone from invoking the debugger remotely by serving
  428.     // up any old file with the x-application-jsd content type.
  429.     if (channel.URI.spec != "x-jsd:debugger")
  430.     {
  431.         debug ("Not handling content from unknown location ``" +
  432.                channel.URI.spec + "''");
  433.         return;
  434.     }
  435.     
  436.     var window = findDebuggerWindow()
  437.  
  438.     if (window)
  439.     {
  440.         window.focus();
  441.     }
  442.     else
  443.     {
  444.         var ass =
  445.             Components.classes[ASS_CONTRACTID].getService(nsIAppShellService);
  446.         window = ass.hiddenDOMWindow;
  447.  
  448.         var args = new Object();
  449.         args.url = channel.URI.spec;
  450.  
  451.         window.openDialog("chrome://venkman/content/venkman.xul", "_blank",
  452.                           "chrome,menubar,toolbar,resizable,dialog=no", args);
  453.     }
  454. }
  455.  
  456. /*****************************************************************************/
  457.  
  458. /* content handler factory object (IRCContentHandler) */
  459. var JSDContentHandlerFactory = new Object();
  460.  
  461. JSDContentHandlerFactory.createInstance =
  462. function jsdhf_create(outer, iid)
  463. {
  464.     if (outer != null)
  465.         throw Components.results.NS_ERROR_NO_AGGREGATION;
  466.  
  467.     if (!iid.equals(nsIContentHandler) && !iid.equals(nsISupports))
  468.         throw Components.results.NS_ERROR_INVALID_ARG;
  469.  
  470.     return new JSDContentHandler();
  471. }
  472.  
  473. /*****************************************************************************/
  474.  
  475. var Module = new Object();
  476.  
  477. Module.registerSelf =
  478. function (compMgr, fileSpec, location, type)
  479. {
  480.     debug("*** Registering -venkman handler.\n");
  481.     
  482.     compMgr =
  483.         compMgr.QueryInterface(Components.interfaces.nsIComponentRegistrar);
  484.  
  485.     compMgr.registerFactoryLocation(CLINE_SERVICE_CID,
  486.                                     "Venkman CommandLine Service",
  487.                                     CLINE_SERVICE_CTRID, 
  488.                                     fileSpec,
  489.                                     location, 
  490.                                     type);
  491.  
  492.     catman = Components.classes[CATMAN_CTRID].getService(nsICategoryManager);
  493.     catman.addCategoryEntry("command-line-argument-handlers",
  494.                             "venkman command line handler",
  495.                             CLINE_SERVICE_CTRID, true, true);
  496.  
  497.     debug("*** Registering x-jsd protocol handler.\n");
  498.     compMgr.registerFactoryLocation(JSDPROT_HANDLER_CID,
  499.                                     "x-jsd protocol handler",
  500.                                     JSDPROT_HANDLER_CTRID, 
  501.                                     fileSpec, 
  502.                                     location,
  503.                                     type);
  504.  
  505.     debug("*** Registering x-application-jsd content handler.\n");
  506.     compMgr.registerFactoryLocation(JSDCNT_HANDLER_CID,
  507.                                     "x-application-jsd content handler",
  508.                                     JSDCNT_HANDLER_CTRID, 
  509.                                     fileSpec, 
  510.                                     location,
  511.                                     type);
  512.     try
  513.     {
  514.         const JSD_CTRID = "@mozilla.org/js/jsd/debugger-service;1";
  515.         const jsdIDebuggerService = Components.interfaces.jsdIDebuggerService;
  516.         var jsds = Components.classes[JSD_CTRID].getService(jsdIDebuggerService);
  517.         jsds.initAtStartup = true;
  518.     }
  519.     catch (ex)
  520.     {
  521.         debug ("*** ERROR initializing debugger service");
  522.         debug (ex);
  523.     }
  524. }
  525.  
  526. Module.unregisterSelf =
  527. function(compMgr, fileSpec, location)
  528. {
  529.     compMgr = compMgr.QueryInterface(Components.interfaces.nsIComponentRegistrar);
  530.  
  531.     compMgr.unregisterFactoryLocation(CLINE_SERVICE_CID, fileSpec);
  532.     catman = Components.classes[CATMAN_CTRID].getService(nsICategoryManager);
  533.     catman.deleteCategoryEntry("command-line-argument-handlers",
  534.                                CLINE_SERVICE_CTRID, true);
  535. }
  536.  
  537. Module.getClassObject =
  538. function (compMgr, cid, iid) {
  539.     if (cid.equals(CLINE_SERVICE_CID))
  540.         return CLineFactory;
  541.  
  542.     if (cid.equals(JSDPROT_HANDLER_CID))
  543.         return JSDProtocolHandlerFactory;
  544.  
  545.     if (cid.equals(JSDCNT_HANDLER_CID))
  546.         return JSDContentHandlerFactory;
  547.     
  548.     if (!iid.equals(Components.interfaces.nsIFactory))
  549.         throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
  550.  
  551.     throw Components.results.NS_ERROR_NO_INTERFACE;
  552.     
  553. }
  554.  
  555. Module.canUnload =
  556. function(compMgr)
  557. {
  558.     return true;
  559. }
  560.  
  561. /* entrypoint */
  562. function NSGetModule(compMgr, fileSpec) {
  563.     return Module;
  564. }
  565.